package com.bite;

import java.sql.SQLOutput;
import java.util.Arrays;

public class Homework {
    //设置一个计数器是奇数就++,是偶数就置0
    public static boolean isOddSeries2(int[] array) {
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if(array[i] % 2 == 1){
                count++;
                if(count == 3) {
                    return true;
                }
            }else {
                count = 0;
            }
        }
        return false;
    }

    public static boolean isOddSeries(int[] array) {
        for (int i = 0; i < array.length-2; i++) {
            if(array[i] % 2 == 1 && array[i+1] % 2 == 1 && array[i+2] % 2 == 1 ) {
                return true;
            }
        }
        return false;
    }
    public static void main8(String[] args) {
        int[] array1 = {1,2,34,3,4,5,7,23,12};
        int[] array2 = {2,6,4,1};
        boolean b1 = isOddSeries(array1);
        boolean b2 = isOddSeries(array2);
        System.out.println(b1);
        System.out.println(b2);
    }
    //投票算法只需要遍历一遍
    public static int searchMore3(int[] array) {
        int candidate = array[0];
        int count = 1;
        for (int i = 1; i < array.length; i++) {
            if (count == 0) {
                candidate = array[i];
                count = 1;
            } else if (array[i] == candidate) {
                count++;
            } else {
                count--;
            }
        }
        return candidate;
    }
    //审题发现他的数量超过n/2所以可以直接先排序,在取中数
    public static int searchMore2(int[] array) {
        Arrays.sort(array);
        return array[array.length / 2];
    }
    //我的方法
    public static int searchMore(int[] array)
    {
        for (int i = 0; i < array.length; i++) {
            int count = 0;//count 要从0开始计数
            for (int j = 0; j < array.length; j++) {
                if (array[i] == array[j]) {//当j=i的时候也会加一次,然后找到另外一个也会加一次
                    count++;
                }
            }
            if (count > array.length / 2){
                return array[i];
            }

        }
        return Integer.MAX_VALUE;
    }

    public static void main7(String[] args) {
        int[] array = {2,2,1,1,1,2,2};
        int ret = searchMore(array);
        System.out.println(ret);

    }
    //n^n = 0
    //n^0 = n
    //用异或来找不相同的数
    public static int searchOne1(int[] array) {
        int ret = 0;
        for (int i = 0; i < array.length; i++) {
            ret ^= array[i];
        }
        return ret;
    }


    //求只出现一次的数
    //分析先取array[i]  count = 1,然后再循环向后取 有元素等于array[i] count++
    public static int searchOne(int[] array)
    {
        for (int i = 0; i < array.length; i++) {
            int count = 0;//count 要从0开始计数
            for (int j = 0; j < array.length; j++) {
                if (array[i] == array[j]) {//当j=i的时候也会加一次,然后找到另外一个也会加一次
                    count++;
                }
            }
            if (count == 1){
                return array[i];
            }

        }
        return Integer.MAX_VALUE;
    }
    public static void main(String[] args) {
        int[] array = {3,3,44,55,55,44,6};
        int ret = searchOne(array);
        System.out.println(searchOne1(array));
        System.out.println(ret);
    }
//    给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标
    //要返回多个值用数组表示
    public static int[] searchIndex(int[] array, int a) {
        int[] ret = new int[2];
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length; j++) {
                if(array[i] + array[j] == a) {
                    ret[0] = i;
                    ret[1] = j;
                    return ret;
                }
            }
        }
        //出现没有找到的情况 用-1和-1来返回
//        ret[0] = -1;
//        ret[1] = -1;
//        return ret;
//        return {-1,-1};//不能这样进行返回
//        return [-1,-1];//这样也不行
//        return (-1,-1);//这样也不行
        return new int[]{-1,-1};
    }
    public static void main5(String[] args) {
        int[] array = {2,7,11,15};//随意定义的一个数组
        int[] ret = searchIndex(array, 1);//查找到数组中哪两个元素之和等于a,返回下标
        System.out.println(Arrays.toString(ret));
        int[] array2 = new int[]{1,2,3,4,5,6};
    }

    //实现一个冒泡排序
    //一趟: 找出一个最大的数排到最后
    //重复跑 直到排序完成
    public static void bubble(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {//注意这里要-i 可以把之前拍好的部分不再继续排了
                boolean flg = false;
                if(array[i] > array [i+1]) {
                    int tmp = array[i];
                    array[i] = array[i+1];
                    array [i+1] = tmp;
                    flg = true;
                }
                if(flg == false) { //假如一次都没换,就相当于已经排好序了,就不用继续排了
                    break;
                }
            }
        }
    }


    public static void main4(String[] args) {
        int[] array = {1, 33, 44 , 123, 35, 55};
        bubble(array);
        System.out.println(Arrays.toString(array));
    }
    //二分查找主要是对比要查找的数和中间数的大小
    //待查找数 > 中数   left = mid + 1
    //待查找数 < 中数   right = mid - 1
    //待查找数 == 中数  return mid
    public static int binary(int[] array, int a){
        int left = 0;
        int right = array.length-1;
        int mid = 0;
        while(left < right) {
            mid = (left + right) / 2;
            if(a > mid) {
                left = mid + 1;
            }else if(a < mid) {
                right = mid - 1;
            }else {
                return mid;
            }
        }
        return -1;
    }

    public static void main3(String[] args) {
        int[] array = {1, 33, 44 , 123, 35, 55};
        int a = 17;
        int index = binary(array, a);
        System.out.println(index);
    }
    //交换奇数和偶数的次序
    public static void reverseOddEven(int[] array) {
        int left = 0;
        int right = array.length-1;
        int tmp = 0;
        while(left < right) {
            //1. 偶数  奇数  交换   然后  left++  right--
            //2. 奇数  奇数  left++
            //3. 偶数  偶数  right--
            //4. 奇数  偶数  left++ right--
            if (array[left] % 2 == 0 && array[right] % 2 == 1) {
                tmp = array[left];
                array[left] = array[right];
                array[right] = tmp;
                left++;
                right--;
            }else if(array[left] % 2 == 1 && array[right] % 2 == 1) {
                left += 1;
            }else if(array[left] % 2 == 0 && array[right] % 2 == 0) {
                right--;
            }else {
                left++;
                right--;
            }
        }

    }

    public static void main2(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 5, 6, 12, 33 ,22};
        System.out.println(Arrays.toString(array));
        System.out.println("==========");
        reverseOddEven(array);
        System.out.println(Arrays.toString(array));
    }

    //把数组中的数据扩大两倍
    public static void transform(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
    }
    public static int[] transform2(int[] array) {
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i] = array[i] * 2;
        }
        return ret;
    }


    public static void main1(String[] args) {
        int[] array = {1, 2, 3};
//        System.out.println(array);//[I@776ec8df "["表示是一个数组 "I"表示数组元素是int类型  "@"进行一个分割 "776ec8df"代表是哈希值映射的地址
        System.out.println(Arrays.toString(array));

//        transform(array);//改变所指向的对象的值
//        System.out.println(array);//[I@776ec8df
        int[] ret = transform2(array);
        System.out.println(Arrays.toString(ret));

    }
}
